home *** CD-ROM | disk | FTP | other *** search
/ Chip 1996 April / CHIP 1996 aprilis (CD06).zip / CHIP_CD06.ISO / hypertxt.arj / 92 / MEGO9209.CD < prev    next >
Text File  |  1995-09-09  |  7KB  |  197 lines
  1.       @VJól megkevertük a kijelzést...@N
  2.  
  3.           Júniusi   számunk   rejtvényeirôl   van   szó.    Utólag
  4.       azonosíthatatlan  ördögök  jóvoltából  lemaradt  a digitális
  5.       kijelzôrôl szóló feladat ábrája, s természetesen megfejtôink
  6.       mindegyike más elrendezést tartott szokásosnak, így  nemcsak
  7.       a kártyák, de a bitek is megkeveredtek. Mea culpa...
  8.  
  9.  
  10.       @VKeverés@N
  11.  
  12.           Lássuk    elôször    a    keverés-osztás    problémáját.
  13.       Emlékeztetôül:  a  megoldandó  feladat  egy bridzs-leosztást
  14.       kiíró program beküldése volt. Az 52 lapos francia kártyát  4
  15.       játékos között  kellett egyenlôen  szétosztani --  lehetôleg
  16.       gyorsan.    Nem    akármirôl   van    szó:    a   lehetséges
  17.       bridzs-leosztások     száma   egészen       pontosan
  18.       53644737765488792839237440000.
  19.           Megoldóink   többsége   két   alapvetô   eljárás   közül
  20.       választott, öten kétféleképpen  is kidolgozták a  feladatot.
  21.       Tizenegyen  küldtek  be  jó  megoldást  --  Pascal,  C,   és
  22.       Modula--2 nyelven.
  23.           Voltak akik ""kártyaszerûen"  gondolkodtak, az 52  lapot
  24.       (vagyis  a  nekik   megfelelô  számokat,  jeleket)   elôször
  25.       megkeverték,  majd  az  így  elôállított  véletlen  (kevert)
  26.       halmaz elemeit sorban kiosztották a játékosok között. Hogyan
  27.       lehet keverni? Itt is két út kínálkozik:
  28.           a/  vegyünk  a  pakliból  2  véletlen  lapot   (helyüket
  29.       megjegyezve),  ezeket  cseréljük  fel,  s  ezt  az  eljárást
  30.       ismételjük  valahányszor (ki  fix értékkel  dolgozott, ki  a
  31.       futtatóra bízta a döntést).
  32.           b/ tegyük  fel, hogy  az elsô  k-1 helyen  már megkevert
  33.       kártyák vannak. Vegyük ki a k. lapot, s ezt cseréljük fel  a
  34.       maradék 52-k lap közül véletlenül kiválasztott lappal.
  35.           Az    eljárás     értelemszerûen    a     paklin    való
  36.       ""végiggyaloglással" ér véget.
  37.           A   másik   fô  megoldási   lehetôség   kártyával  kissé
  38.       nehezebben realizálható:  tudniillik nem  keverünk, hanem  a
  39.       pakliból  véletlenszerûen  választva rögtön  lapot  adunk az
  40.       egyes játékosoknak. (Megjegyzendô, hogy ez szintén  keverés,
  41.       csak éppen nem egy tömbön belül, hanem két tömböt  használva
  42.       dolgozunk.)  Kérdés,   mit  csináljunk   a  kihúzott   lapok
  43.       ""helyével"?  Ha  üresen  hagyjuk  ezeket,  akkor  az osztás
  44.       végefelé érzékelhetôen lelassul a programunk, hiszen ha üres
  45.       helyre    ""bök"    a    véletlenszám-generátorunk,    akkor
  46.       sorsolhatunk újra, s mondjuk 45 üres hely esetén ez már elég
  47.       sok  helybenjárást jelent.  Csináljuk azt,  ami a  kártyával
  48.       spontán megtörténik: az  üres helyekre a  pakli ""benyomul".
  49.       îgy   egyre   kisebb,  szorosan   feltöltött   tömbbôl  kell
  50.       sorsolnunk, egészen addig, míg egyetlen elem marad.
  51.           A közölt megoldás (1.  lista -- Horváth Sándor  munkája)
  52.       ez utóbbi utat járja be,  elegáns módon -- a francia  kártya
  53.       jelöléseivel -- kiíratva a kikevert leosztást.
  54.           A  júniusi  nyertes  pedig  (egy  doboz  Tungsram floppy
  55.       tulajdonosa) -- keverés, húzás után -- Varga József lett.
  56.  
  57.  
  58.       @VKijelzés@N
  59.  
  60.           A feladat az alábbi volt  (most már az ígért ábrával  --
  61.       jobb késôn, mint soha): a számológépek többsége a  decimális
  62.       számjegyeket egy hét  vonalat tartalmazó keret  segítségével
  63.       jelzi ki.
  64.           îrjunk egy olyan programot,  amely egy 16 bites  pozitív
  65.       egészhez (például a Pascal @Kword@N típusa), megadja a kijelzési
  66.       módját, azaz öt hétjegyû bináris számot, melyek egyes bitjei
  67.       pontosan akkor 1 értékûek,  ha a megfelelô vonal  szerepel a
  68.       kijelzésben.  Más  elrendezés  használata  (s  a  13 megoldó
  69.       szinte  kivétel  nélkül  ""egyedi"  kijelzôt  tervezett),  a
  70.       megoldás értékét természetesen nem befolyásolta.
  71.           A  megfejtôk két  részletben oldották  meg a  feladatot.
  72.       Elôször  --  általában ""kézimunkával"  --  elkészítették az
  73.       egyes   számjegyek   ""képét",   azaz   a   nekik  megfelelô
  74.       bitkiosztást.  Valószínûleg  ezt  a  részt  nem  is  érdemes
  75.       algoritmizálni, hiszen pillanatok  alatt megalkotható a  tíz
  76.       számjegynek  megfelelô bitsorozat,  melyeket aztán  konstans
  77.       tömbként tárolhatunk a programban.  Ezt kell hogy kövesse  a
  78.       kijelzendô szám  jegyekre szeletelése.  Az egyes  megoldások
  79.       különbözôségét  --  az  elrendezésen  túl  --  elsôsorban  a
  80.       ""szolgáltatások"  mennyisége   okozta.  Bitsorozat   kontra
  81.       kijelzés,   kezdô   szóközök,  nullák   kiíratása   stb.  És
  82.       természetesen  volt  nyúlfarknyi  hibátlan,  s  több oldalas
  83.       hibásan mûködô (egyjegyû számokat nem ismerô) lista is.
  84.           A mintaként  közölt megoldás  (2. lista  -- Dudás József
  85.       programja) viszonylagos hosszúságának  oka, hogy a  kitûzött
  86.       feladaton   (bitsorozat   megadása)   túlmenôen    látványos
  87.       kijelzést valósít meg.
  88.           A  helyes  megoldást  beküldôk  a  decemberi  sorsoláson
  89.       vesznek részt.
  90.  
  91.       @KBánhegyesi Zoltán@N
  92.  
  93.  
  94. program kever;
  95. {Horváth Sándor}
  96.  
  97. uses crt;
  98. const
  99.   szin: array[0..3] of char = (#3,#4,#5,#6);
  100.   szam: array[0..12] of string[2]=
  101.    ('2','3','4','5','6','7','8','9','10',
  102.     'J','Q','K','A');
  103.  
  104. var pakli: array[0..51] of byte;
  105.     i,lap: byte;
  106.  
  107. begin
  108.    clrscr;
  109.    randomize;
  110.    for i:=0 to 51 do pakli[i]:=i;
  111.    for i:=0 to 3 do write(chr(49+i),'. jatekos  ');
  112.    for i:=51 downto 0 do begin
  113.      lap:=random(i+1);
  114.      gotoxy(((51-i) mod 4) * 11 +4,
  115.       ((51-i) div 4) +3);
  116.      write(szin[pakli[lap] div 13] + ' '
  117.       + szam[pakli[lap] mod 13]);
  118.      pakli[lap]:=pakli[i];
  119.    end;
  120.    repeat until keypressed;
  121. end.
  122.  
  123.  
  124. program dec_kijelzo(input,output);
  125. {Dudás János}
  126.  
  127. uses crt;
  128. const
  129.       dec_szamjegy:array[0..9] of byte=
  130.                    (64+32+16+8+4+1,
  131.                     64+16,
  132.                     32+16+4+2+1,
  133.       { dec_szamjegy[i.] eleme }    64+16+4+2+1,
  134.       { az i szam bináris 7 bites } 64+16+8+2,
  135.       { képe a keret számozásnak  } 64+8+4+2+1,
  136.       { megfelelöen }           64+32+8+4+2+1,
  137.                     64+16+4,
  138.                     64+32+16+8+4+2+1,
  139.                     64+16+8+4+2+1);
  140.       f=#219;
  141.       v=f+f+f+f+f+f+f;
  142.       keret:array[0..6,1..2] of byte=
  143.        ((0,8),(0,4),(0,0),(0,0),(6,0),(0,5),(6,5));
  144.       { A megjelenítéshez a 0..6 vonalak eltolásai }
  145.  
  146. var szam:word;          { Az input }
  147.     i,j:byte;
  148.     kszam:array[1..5] of byte;
  149.      { A szam decimális számjegyei a vonalak
  150.        számozásának megfelelöen, binárisan }
  151.  
  152. function hatvany(alap,kitevo:byte):longint;
  153. begin
  154.  hatvany:=round(exp(ln(alap)*kitevo));
  155. end;
  156.  
  157. procedure bit_ki(x,y,j:byte);
  158. begin
  159. if j>2 then
  160.  begin
  161.   gotoxy(x,y);write(f);
  162.   gotoxy(x,y+1);write(f);
  163.   gotoxy(x,y+2);write(f);
  164.   gotoxy(x,y+3);write(f);
  165.  end
  166.  else
  167.   begin
  168.    gotoxy(x,y);write(v);
  169.   end;
  170. end;
  171.  
  172. procedure kijelzes(x,y:byte);
  173. var bin_jegy:byte;
  174. begin
  175.  for i:=1 to 5 do
  176.  for j:=0 to 6 do
  177.   begin
  178.    bin_jegy:=(kszam[i] mod hatvany(2,j+1))
  179.     div hatvany(2,j);
  180.    if bin_jegy=1 then
  181.     bit_ki(x+9*(5-i)+keret[j,1],y+keret[j,2],j);
  182.   end;
  183. end;
  184.  
  185. begin
  186.  clrscr;
  187.  write('A kijelezni kivant szam (0<=x<=65535): ');
  188.  readln(szam);
  189.  for i:=1 to 5 do
  190.   begin
  191.    kszam[i]:=dec_szamjegy[(szam mod hatvany(10,i))
  192.     div hatvany(10,i-1)];
  193.   end;
  194.  kijelzes(18,8);
  195.  readln;
  196. end.
  197.